/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Domain;

import Delta.Fiber;
import Delta.Layer;
import Delta.Lamel;
import java.io.Serializable;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.TreeMap;
import Exceptions.*;

/**
 *
 * @author Memet
 */
public class Data implements Serializable{



    TreeMap<Integer, Materiaal> m; // materialen
    TreeMap<String, Laminaat> l;//laminaten
    //TreeMap<Integer, Vezel> v; //vezels
    //TreeMap<Integer, Epoxy> e;//epoxy's
    
    TreeMap<Integer, Materie> materies;
    TreeMap<Integer, Layer> layers;
    TreeMap<Integer, Delta.Lamel> lamels;
    TreeMap<Integer, Fiber> fibers;
    TreeMap<Integer, Delta.Epoxy> epoxys;
    TreeMap<String, Delta.Laminaat> laminates;

    //tellertjes
    int fiberTeller;
    int epoxyTeller;
    int materialTeller;
    int laminateTeller;
    int ansysMaterialIDTeller;
    int ansysLaminateIDTeller;


    /**
     * maakt een nieuwe databank aan
     */
    public Data() {
        m=new TreeMap<Integer, Materiaal>();
        l=new TreeMap<String, Laminaat>();
        //v=new TreeMap<Integer, Vezel>();
        //e=new TreeMap<Integer, Epoxy>();
        
        fibers = new TreeMap<>();
        materies=new TreeMap<>();
        layers = new TreeMap<>();
        epoxys = new TreeMap<>();
        lamels = new TreeMap<>();
        laminates = new TreeMap<>();
        
        fiberTeller = 1;
        epoxyTeller = 1;
        materialTeller = 1;
        laminateTeller = 1;
        ansysLaminateIDTeller = 10;
        ansysMaterialIDTeller = 10;
    }

    /**
     * voegt nieuw materiaal toe aan databank
     * @param mat het materiaal
     * @return het id van het materiaal
     * @throws NameAlreadyExistsException
     */
    public int addMateriaal(Materiaal mat) throws NameAlreadyExistsException
    {
        try{
            if(this.m.containsValue(mat))
            {
                throw new NameAlreadyExistsException();
            }
            this.m.put(m.lastKey()+1, mat);
            mat.setId(m.lastKey());
        }
        catch(NoSuchElementException ex)
        {
            this.m.put(0, mat);
            mat.setId(0);
        }

        return this.m.lastKey();
    }

    /**
     * Geeft het materiaal
     * @param matID het id van het materiaal
     * @return het materiaal
     */
    public Materiaal getMateriaal(int matID)
    {
        return this.m.get(matID);
    }

    /**
     * Geeft het materiaal
     * @param matID het id van het materiaal
     * @return het materiaal
     */
    public Materiaal getMateriaal(String mat)
    {
        Iterator<Materiaal> it = this.m.values().iterator();
        while(it.hasNext())
        {
            Materiaal m = it.next();
            if(m.getNaam().equalsIgnoreCase(mat))
            {
                return m;
            }
        }
        return null;
    }

//    /**
//     * Voegt nieuw laminaat toe
//     * @param laminaat het laminaat
//     * @param naam de naam van het laminaat
//     * @return de naam van het laminaat
//     * @throws NameAlreadyExistsException
//     * @throws InvalidNameException
//     */
//    public String setLaminaat(Laminaat laminaat, String naam) throws NameAlreadyExistsException, InvalidNameException
//    {
////        if(laminaat.getNaam().equalsIgnoreCase(java.util.ResourceBundle.getBundle("laminaatprog/Bundle").getString("NAAMLOOS")))
////        {
////            throw new InvalidNameException();
////        }
//        
//        this.l.put(naam, laminaat);
//        return this.l.lastKey();
//    }

//    /**
//     * Voegt nieuw laminaat toe
//     * @param laminaat het laminaat (met naam)
//     * @return de naam van het laminaat
//     * @throws InvalidNameException
//     */
//    public String addLaminaat(Laminaat laminaat) throws InvalidNameException
//    {
////        if(laminaat.getNaam().equalsIgnoreCase(java.util.ResourceBundle.getBundle("laminaatprog/Bundle").getString("NAAMLOOS")))
////        {
////            throw new InvalidNameException();
////        }
//        this.l.put(laminaat.getNaam(), laminaat);
//        return this.l.lastKey();
//    }

//    /**
//     * Geeft het laminaat
//     * @param naam de naam van het laminaat
//     * @return het laminaat
//     */
//    public Laminaat getLaminaat(String naam)
//    {
//        return this.l.get(naam);
//    }

    public void setMateriaal(Materiaal oud, Materiaal nieuw)
    {
        nieuw.setId(oud.getId());
        this.m.put(oud.getId(), nieuw);
    }


    /**
     * Geeft alle laminaten
     * @return de Laminaten
     */
    public Iterator<Laminaat> getLaminaten()
    {
        return l.values().iterator();
    }

    /**
     * Geeft alle materialen
     * @return de materialen
     */
    public Iterator<Materiaal> getMaterialen()
    {
        return m.values().iterator();
    }

    public boolean matWordtGebruikt(Materiaal m) {
        Iterator<Laminaat> it = this.l.values().iterator();
        while(it.hasNext())
        {
            Laminaat lam = it.next();
            for(int i = 0; i<lam.getLam().getRowDimension(); i++)
            {
                if(m.getId() == lam.getLam().get(i, 1))
                {
                    return true;
                }
            }
        }
        return false;
    }

    public void deleteMateriaal(Materiaal mat)
    {
        if(!matWordtGebruikt(mat))
        {
            this.m.remove(mat.getId());
        }
    }
    
    
//    public int addVezel(Vezel vez) throws NameAlreadyExistsException
//    {
//        try{
//            if(this.v.containsValue(vez))
//            {
//                throw new NameAlreadyExistsException();
//            }
//            this.v.put(v.lastKey()+1, vez);
//        }
//        catch(NoSuchElementException ex)
//        {
//            this.v.put(0, vez);
//        }
//        return this.v.lastKey();
//    }
    
//    public int addEpoxy(Epoxy ep) throws NameAlreadyExistsException
//    {
//        try{
//            if(this.e.containsValue(ep))
//            {
//                throw new NameAlreadyExistsException();
//            }
//            int id = e.lastKey()+1;
//            this.e.put(id, ep);
//            ep.setNr(id);
//        }
//        catch(NoSuchElementException ex)
//        {
//            this.e.put(0, ep);
//            ep.setNr(0);
//        }
//        return this.e.lastKey();
//    }

//    public Iterator<Vezel> getVezels() {
//        return v.values().iterator();
//    }

    public String geefNieuweFiberNaam()
    {
        String out = String.valueOf(fiberTeller);
        if(fiberTeller<10)
        {
            out = "0"+out;
        }
        return out;
    }

    public void gebruikNieuweVezelNaam()
    {
        fiberTeller++;
    }

    public String geefNieuweEpoxyNaam()
    {
        String out = String.valueOf(epoxyTeller);
        if(epoxyTeller<10)
        {
            out = "0"+out;
        }
        return out;
    }

    public void gebruikNieuweEpoxyNaam()
    {
        epoxyTeller++;
    }

    public String geefNieuweMaterialNaam()
    {
        String out = String.valueOf(materialTeller);
        if(materialTeller<10)
        {
            out = "0"+out;
        }
        return out;
    }

    public void gebruikNieuweMaterialNaam()
    {
        materialTeller++;
    }

    public String geefNieuweLaminateNaam()
    {
        String out = String.valueOf(laminateTeller);
        if(laminateTeller<10)
        {
            out = "0"+out;
        }
        return out;
    }

    public void gebruikNieuweLaminateNaam()
    {
        laminateTeller++;
    }

//    public Iterator<Epoxy> getEpoxys() {
//        return e.values().iterator();
//    }

//    public void deleteFiber(Vezel fib) {
//        int id = fib.getNr();
//        v.remove(id);
//    }

//    public void deleteEpoxy(Epoxy epo) {
//        int id = epo.getNr();
//        e.remove(id);
//    }

//    public boolean epoxyNotUsed(Epoxy epo) {
//        Iterator<Materiaal> it = getMaterialen();
//        while(it.hasNext())
//        {
//            try{
//                Materiaal geselecteerd = it.next();
//                if(geselecteerd.getClass().getSimpleName().equals(Lamel.class.getSimpleName()))
//                {
//                    Lamel l = (Lamel) geselecteerd;
//                    if(l.getM().equals(epo))
//                    {
//                        return false;
//                    }
//                }
//                else
//                {
//
//                }
//            }
//            catch(Exception ex)
//            {
//
//            }
//
//        }
//        return true;
//    }

    public int getNextAnsysMaterialID() {
        ansysMaterialIDTeller++;
        return ansysMaterialIDTeller;
    }

    public void setAnsysMaterialID(int id) {
        this.ansysMaterialIDTeller = id;
    }

    public int getLastAnsysMaterialID() {
        return ansysMaterialIDTeller;
    }

    public int getLastAnsysLaminateID() {
        return ansysLaminateIDTeller;
    }
    public int getNextAnsysLaminateID() {
        ansysLaminateIDTeller++;
        return ansysLaminateIDTeller;
    }

    public void setAnsysLaminateID(int ansysLaminateIDTeller) {
        this.ansysLaminateIDTeller = ansysLaminateIDTeller;
    }

    public int getAantalLaminaten() {
        return l.size();
    }

    public void deleteLaminate(Laminaat lam) {
        l.remove(lam.getNaam());
    }

    public boolean materialenEmpty() {
        //oud// return m.isEmpty();
        return lamels.isEmpty();
    }

    
    
    
    
    
    
    
    
    
    public void deleteFiber(Fiber fib) {
        int id = fib.getNr();
        fibers.remove(id);
    }
    
    public Iterator<Layer> getLayers()
    {
        return layers.values().iterator();
    }
    
    
    /**
     * Gets all lamels
     * @return iterator of all lamels
     */
    public Iterator<Delta.Lamel> getLamels()
    {
        return lamels.values().iterator();
    }
    
    public boolean fiberNotUsed(Fiber f) {
        Iterator<Lamel> it = getLamels();
        
        while(it.hasNext())
        {
            try{
                    Lamel l = it.next();
                    if(l.getClass().getSimpleName().equals(Lamel.class.getSimpleName()))
                    {
                        //Lamel l = (Lamel) geselecteerd;
                        if(l.getMyFiber().equals(f))
                        {
                            return false;
                        }
                    }
                    else
                    {

                    }
                }
                catch(Exception ex)
                {

                }
        }
        return true;
    }
    
    public int addFiber(Fiber f) throws NameAlreadyExistsException
    {
        try{
            if(this.fibers.containsValue(f))
            {
                throw new NameAlreadyExistsException();
            }
            this.fibers.put(fibers.lastKey()+1, f);
        }
        catch(NoSuchElementException ex)
        {
            this.fibers.put(0, f);
        }
        return this.fibers.lastKey();
    }
    
    public int addLayer(Layer l) throws NameAlreadyExistsException
    {
        try{
            if(this.layers.containsValue(l))
            {
                throw new NameAlreadyExistsException();
            }
            this.layers.put(layers.lastKey()+1, l);
        }
        catch(NoSuchElementException ex)
        {
            this.layers.put(0, l);
        }
        return this.layers.lastKey();
    }
    
    public int addLamel(Lamel l) throws NameAlreadyExistsException
    {
        try{
            if(this.lamels.containsValue(l))
            {
                throw new NameAlreadyExistsException();
            }
            this.lamels.put(lamels.lastKey()+1, l);
        }
        catch(NoSuchElementException ex)
        {
            this.lamels.put(0, l);
        }
        return this.lamels.lastKey();
    }
    
    public Iterator<Fiber> getFibers() {
        return fibers.values().iterator();
    }

    public int addEpoxy(Delta.Epoxy ep) throws NameAlreadyExistsException
    {
        try{
            if(this.epoxys.containsValue(ep))
            {
                throw new NameAlreadyExistsException();
            }
            int id = epoxys.lastKey()+1;
            this.epoxys.put(id, ep);
            ep.setNr(id);
        }
        catch(NoSuchElementException ex)
        {
            this.epoxys.put(0, ep);
            ep.setNr(0);
        }
        return this.epoxys.lastKey();
    }
    
    public Iterator<Delta.Epoxy> getEpoxys() {
        return epoxys.values().iterator();
    }
    
    public void deleteEpoxy(Delta.Epoxy epo) {
        int id = epo.getNr();
        epoxys.remove(id);
    }
    
    public boolean epoxyNotUsed(Delta.Epoxy f) {
        Iterator<Lamel> it = getLamels();
        while(it.hasNext())
        {
            try{
                    Lamel l = it.next();
                    if(l.getClass().getSimpleName().equals(Lamel.class.getSimpleName()))
                    {
                        //Layer l = (Layer) geselecteerd;
                        if(l.getMyEpoxy().equals(f))
                        {
                            return false;
                        }
                    }
                    else
                    {

                    }
                }
                catch(Exception ex)
                {

                }
        }
        return true;
    }
    
    public void setLamel(Lamel oud, Lamel nieuw)
    {
        nieuw.setId(oud.getId());
        this.lamels.put(oud.getId(), nieuw);
    }
    
    public void deleteLamel(Lamel lamel)
    {
        if(!lamelWordtGebruikt(lamel))
        {
            this.m.remove(lamel.getId());
        }
    }
    
    public boolean lamelWordtGebruikt(Delta.Lamel l) {
        Iterator<Delta.Laminaat> it = this.laminates.values().iterator();
        while(it.hasNext())
        {
            Delta.Laminaat lam = it.next();
            
            for (Layer layer : lam.layers)
            {
                if (l.getId() == layer.getLamel().getId())
                    return true;
            }
        }
        return false;
    }
    
    public void deleteLaminaat(Delta.Laminaat lam) {
        laminates.remove(lam.getName());
    }
    
    //A/Geen invalidNameException omdat er toch niets mee gedaan werd in de oorspronkelijke methode
    public String addLaminaat(Delta.Laminaat laminaat)
    {
        this.laminates.put(laminaat.getName(), laminaat);
        return this.laminates.lastKey();
    }
    
    /**
     * Voegt nieuw laminaat toe
     * @param laminaat het laminaat
     * @param naam de naam van het laminaat
     * @return de naam van het laminaat
     * @throws NameAlreadyExistsException
     * @throws InvalidNameException
     */
    public String setLaminaat(Delta.Laminaat laminaat, String naam) throws NameAlreadyExistsException, InvalidNameException
    {
        this.laminates.put(naam, laminaat);
        return this.laminates.lastKey();
    }
    

    public Delta.Laminaat getLaminaat(String naam)
    {
        return this.laminates.get(naam);
    }
    
    /**
     * Gets all Laminates
     * @return de Laminaten
     */
    public Iterator<Delta.Laminaat> getLaminates()
    {
        return laminates.values().iterator();
    }
    
    public int getLaminatesCount() {
        return laminates.size();
    }
}
